{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# Understanding LangGraph"
      ],
      "metadata": {
        "id": "K_5AjNZyzx6J"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "LangGraph is a special LangChain-built library that focuses on building intelligent AI Agents using graphs. Ie, agentic state machines."
      ],
      "metadata": {
        "id": "8YNmQM5PzxAG"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "We need these prerequisite libraries to run a graph visualization library (`pygraphviz`). We will use this library during this notebook to understand the structure of our graphs _but_ it is not required to use `langgraph`."
      ],
      "metadata": {
        "id": "Ri4iY0cqz2mr"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!apt-get install python3-dev graphviz libgraphviz-dev pkg-config"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TCVLlfNyAtxD",
        "outputId": "e285663c-c65a-45e6-81c1-5140b74a28da"
      },
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Reading package lists... Done\n",
            "Building dependency tree... Done\n",
            "Reading state information... Done\n",
            "pkg-config is already the newest version (0.29.2-1ubuntu3).\n",
            "graphviz is already the newest version (2.42.2-6).\n",
            "libgraphviz-dev is already the newest version (2.42.2-6).\n",
            "python3-dev is already the newest version (3.10.6-1~22.04).\n",
            "0 upgraded, 0 newly installed, 0 to remove and 45 not upgraded.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "We need a few libraries from LangChain:"
      ],
      "metadata": {
        "id": "3VbV6-nrlVtq"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "FUt2EoJZu6M3"
      },
      "outputs": [],
      "source": [
        "!pip install -qU \\\n",
        "    langchain-openai==0.1.3 \\\n",
        "    langchain==0.1.16 \\\n",
        "    langchain-core==0.1.42 \\\n",
        "    langgraph==0.0.37 \\\n",
        "    langchainhub==0.1.15 \\\n",
        "    pygraphviz==1.12  # for visualizing"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Graph State\n",
        "\n",
        "We will define a custom graph state to support our agent-oriented decision making. In this we will define:\n",
        "\n",
        "* our user `input` (ie the most recent message from the user)\n",
        "* `agent_out` which is used by the graph (and our final output) to consume/output agent outputs\n",
        "* `intermediate_steps` which is a list maintained over our graph runtime to keep track of the results of previous steps\n",
        "\n",
        "During each step in our graph we will be able to add to, modify, or extract these values from our state object."
      ],
      "metadata": {
        "id": "hITmdwQ7Qns0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from typing import TypedDict, Annotated, List, Union\n",
        "from langchain_core.agents import AgentAction, AgentFinish\n",
        "import operator\n",
        "\n",
        "\n",
        "class AgentState(TypedDict):\n",
        "    input: str\n",
        "    agent_out: Union[AgentAction, AgentFinish, None]\n",
        "    intermediate_steps: Annotated[list[tuple[AgentAction, str]], operator.add]"
      ],
      "metadata": {
        "id": "x7Fj9KNjQvUq"
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Emulate Search"
      ],
      "metadata": {
        "id": "5KcxUIVh2jRq"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "To test a RAG-like agent we'll provide a tool that provide information as we would expect a search tool in a RAG agent to do."
      ],
      "metadata": {
        "id": "ub-P5EWL2lPA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "ehi_information = \"\"\"Title: EHI: End-to-end Learning of Hierarchical Index for\n",
        "Efficient Dense Retrieval\n",
        "Summary: Dense embedding-based retrieval is now the industry\n",
        "standard for semantic search and ranking problems, like obtaining relevant web\n",
        "documents for a given query. Such techniques use a two-stage process: (a)\n",
        "contrastive learning to train a dual encoder to embed both the query and\n",
        "documents and (b) approximate nearest neighbor search (ANNS) for finding similar\n",
        "documents for a given query. These two stages are disjoint; the learned\n",
        "embeddings might be ill-suited for the ANNS method and vice-versa, leading to\n",
        "suboptimal performance. In this work, we propose End-to-end Hierarchical\n",
        "Indexing -- EHI -- that jointly learns both the embeddings and the ANNS\n",
        "structure to optimize retrieval performance. EHI uses a standard dual encoder\n",
        "model for embedding queries and documents while learning an inverted file index\n",
        "(IVF) style tree structure for efficient ANNS. To ensure stable and efficient\n",
        "learning of discrete tree-based ANNS structure, EHI introduces the notion of\n",
        "dense path embedding that captures the position of a query/document in the tree.\n",
        "We demonstrate the effectiveness of EHI on several benchmarks, including\n",
        "de-facto industry standard MS MARCO (Dev set and TREC DL19) datasets. For\n",
        "example, with the same compute budget, EHI outperforms state-of-the-art (SOTA)\n",
        "in by 0.6% (MRR@10) on MS MARCO dev set and by 4.2% (nDCG@10) on TREC DL19\n",
        "benchmarks.\n",
        "Author(s): Ramnath Kumar, Anshul Mittal, Nilesh Gupta, Aditya Kusupati,\n",
        "Inderjit Dhillon, Prateek Jain\n",
        "Source: https://arxiv.org/pdf/2310.08891.pdf\"\"\""
      ],
      "metadata": {
        "id": "IS7G1n292sV8"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Custom Tools\n",
        "\n",
        "We will define two tools for this agent, a `search` tool (which emulates our RAG component) and a `final_answer` tool — which is provides output in a specific format, ie:\n",
        "\n",
        "```json\n",
        "{\n",
        "    \"answer\": \"<LLM generated answer here>\",\n",
        "    \"source\": \"<LLM generated citation here>\"\n",
        "}\n",
        "```\n",
        "\n",
        "We define both using the `@tool` decorator from LangChain."
      ],
      "metadata": {
        "id": "zlVbgX39Rhxj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from langchain_core.tools import tool\n",
        "\n",
        "@tool(\"search\")\n",
        "def search_tool(query: str):\n",
        "    \"\"\"Searches for information on the topic of artificial intelligence (AI).\n",
        "    Cannot be used to research any other topics. Search query must be provided\n",
        "    in natural language and be verbose.\"\"\"\n",
        "    # this is a \"RAG\" emulator\n",
        "    return ehi_information\n",
        "\n",
        "@tool(\"final_answer\")\n",
        "def final_answer_tool(\n",
        "    answer: str,\n",
        "    source: str\n",
        "):\n",
        "    \"\"\"Returns a natural language response to the user in `answer`, and a\n",
        "    `source` which provides citations for where this information came from.\n",
        "    \"\"\"\n",
        "    return \"\""
      ],
      "metadata": {
        "id": "SPcrbQfdRrda"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "These tools will be triggered via OpenAI Tools (ie function calling). The LLM will be provided information on the schema (ie structure) of the function to be called, like that which we can see here:"
      ],
      "metadata": {
        "id": "9QoO2wrvmBHw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "search_tool"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iAbQ4Tuz0qET",
        "outputId": "4ca983bb-9a98-4647-a9a3-6c9248b986d2"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "StructuredTool(name='search', description='search(query: str) - Searches for information on the topic of artificial intelligence (AI).\\n    Cannot be used to research any other topics. Search query must be provided\\n    in natural language and be verbose.', args_schema=<class 'pydantic.v1.main.searchSchema'>, func=<function search_tool at 0x7c2e2c357520>)"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Initialize Agent"
      ],
      "metadata": {
        "id": "E8OsQ3tIS-_t"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "from langchain.agents import create_openai_tools_agent\n",
        "from langchain import hub\n",
        "from langchain_openai import ChatOpenAI\n",
        "\n",
        "os.environ[\"OPENAI_API_KEY\"] = os.getenv(\"OPENAI_API_KEY\") or \"sk-...\"\n",
        "\n",
        "llm = ChatOpenAI(temperature=0)\n",
        "\n",
        "prompt = hub.pull(\"hwchase17/openai-functions-agent\")\n",
        "\n",
        "query_agent_runnable = create_openai_tools_agent(\n",
        "    llm=llm,\n",
        "    tools=[final_answer_tool, search_tool],\n",
        "    prompt=prompt\n",
        ")"
      ],
      "metadata": {
        "id": "0gKxRe4tTBHX"
      },
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Test the agent quickly to confirm it is functional:"
      ],
      "metadata": {
        "id": "ESCSupKbTuVR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "inputs = {\n",
        "    \"input\": \"what are EHI embeddings?\",\n",
        "    \"intermediate_steps\": []\n",
        "}\n",
        "agent_out = query_agent_runnable.invoke(inputs)\n",
        "agent_out"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "p5xMQ8ajTxFQ",
        "outputId": "e7bf3e34-f751-42c8-c896-fc37f39a8e3c"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[ToolAgentAction(tool='search', tool_input={'query': 'EHI embeddings'}, log=\"\\nInvoking: `search` with `{'query': 'EHI embeddings'}`\\n\\n\\n\", message_log=[AIMessage(content='', additional_kwargs={'tool_calls': [{'index': 0, 'id': 'call_lnb9cUYfYUD2IXfjd5aaBM6z', 'function': {'arguments': '{\"query\":\"EHI embeddings\"}', 'name': 'search'}, 'type': 'function'}]}, response_metadata={'finish_reason': 'tool_calls'}, id='run-bdfd0e63-4422-4360-ad79-36b0df05cc35-0', tool_calls=[{'name': 'search', 'args': {'query': 'EHI embeddings'}, 'id': 'call_lnb9cUYfYUD2IXfjd5aaBM6z'}])], tool_call_id='call_lnb9cUYfYUD2IXfjd5aaBM6z')]"
            ]
          },
          "metadata": {},
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "agent_out[-1].message_log[-1].additional_kwargs[\"tool_calls\"][-1]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "u7wUMr2BUBt7",
        "outputId": "18c0d1c5-9dd1-46ad-9524-e80c3d06f34a"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'index': 0,\n",
              " 'id': 'call_lnb9cUYfYUD2IXfjd5aaBM6z',\n",
              " 'function': {'arguments': '{\"query\":\"EHI embeddings\"}', 'name': 'search'},\n",
              " 'type': 'function'}"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The agent won't perform the function calls themselvs, that is up to us and we will handle it in downstream actions through our agent graph.\n",
        "\n",
        "The information provided by `agent_out` will be used to decide whether we move to the `search` or `END` nodes of our graph. We'll also add a `error` handler node in case our agent fails to produce the output we need."
      ],
      "metadata": {
        "id": "3giyC0tSoE_I"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Define Nodes for Graph"
      ],
      "metadata": {
        "id": "h6pAxC9kcY1F"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from langchain_core.agents import AgentFinish\n",
        "import json\n",
        "\n",
        "def run_query_agent(state: list):\n",
        "    print(\"> run_query_agent\")\n",
        "    agent_out = query_agent_runnable.invoke(state)\n",
        "    return {\"agent_out\": agent_out}\n",
        "\n",
        "def execute_search(state: list):\n",
        "    print(\"> execute_search\")\n",
        "    action = state[\"agent_out\"]\n",
        "    tool_call = action[-1].message_log[-1].additional_kwargs[\"tool_calls\"][-1]\n",
        "    out = search_tool.invoke(\n",
        "        json.loads(tool_call[\"function\"][\"arguments\"])\n",
        "    )\n",
        "    return {\"intermediate_steps\": [{\"search\": str(out)}]}\n",
        "\n",
        "def router(state: list):\n",
        "    print(\"> router\")\n",
        "    if isinstance(state[\"agent_out\"], list):\n",
        "        return state[\"agent_out\"][-1].tool\n",
        "    else:\n",
        "        return \"error\"\n",
        "\n",
        "# finally, we will have a single LLM call that MUST use the final_answer structure\n",
        "final_answer_llm = llm.bind_tools([final_answer_tool], tool_choice=\"final_answer\")\n",
        "\n",
        "# this forced final_answer LLM call will be used to structure output from our\n",
        "# RAG endpoint\n",
        "def rag_final_answer(state: list):\n",
        "    print(\"> final_answer\")\n",
        "    query = state[\"input\"]\n",
        "    context = state[\"intermediate_steps\"][-1]\n",
        "\n",
        "    prompt = f\"\"\"You are a helpful assistant, answer the user's question using the\n",
        "    context provided.\n",
        "\n",
        "    CONTEXT: {context}\n",
        "\n",
        "    QUESTION: {query}\n",
        "    \"\"\"\n",
        "    out = final_answer_llm.invoke(prompt)\n",
        "    function_call = out.additional_kwargs[\"tool_calls\"][-1][\"function\"][\"arguments\"]\n",
        "    return {\"agent_out\": function_call}\n",
        "\n",
        "# we use the same forced final_answer LLM call to handle incorrectly formatted\n",
        "# output from our query_agent\n",
        "def handle_error(state: list):\n",
        "    print(\"> handle_error\")\n",
        "    query = state[\"input\"]\n",
        "    prompt = f\"\"\"You are a helpful assistant, answer the user's question.\n",
        "\n",
        "    QUESTION: {query}\n",
        "    \"\"\"\n",
        "    out = final_answer_llm.invoke(prompt)\n",
        "    function_call = out.additional_kwargs[\"tool_calls\"][-1][\"function\"][\"arguments\"]\n",
        "    return {\"agent_out\": function_call}"
      ],
      "metadata": {
        "id": "-JGJGvDVcbvq"
      },
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Define Graph"
      ],
      "metadata": {
        "id": "zwv4EsTKeZzh"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Our graph is constructed of **nodes** and **edges**. A node represents a function (one of those we just defined above) whereas an edge allows us to travel from one node to another.\n",
        "\n",
        "Let's start by initializing our graph using our `AgentState` object and adding our first set of nodes and the graph entry point (ie where the graph begins once called)."
      ],
      "metadata": {
        "id": "b1Fd--b9tfYC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from langgraph.graph import StateGraph\n",
        "\n",
        "graph = StateGraph(AgentState)\n",
        "\n",
        "# we have four nodes that will consume our agent state and modify\n",
        "# our agent state based on some internal process\n",
        "graph.add_node(\"query_agent\", run_query_agent)\n",
        "graph.add_node(\"search\", execute_search)\n",
        "graph.add_node(\"error\", handle_error)\n",
        "graph.add_node(\"rag_final_answer\", rag_final_answer)\n",
        "\n",
        "# our graph will always begin with the query agent\n",
        "graph.set_entry_point(\"query_agent\")"
      ],
      "metadata": {
        "id": "IWm31Nj2uLck"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "In addition to our nodes we have our \"one-way\" edges — that is, once node X is called the state must continue to node Y as defined by these edges. We define these using:\n",
        "\n",
        "```python\n",
        "graph.add_edge(X, Y)\n",
        "```\n",
        "\n",
        "If `X` or `Y` are defined nodes in our graph we pass the name of that node in string format. So, if we want to add an edge that navigates from our `\"search\"` node to our `\"rag_final_answer\"` node, we do:\n",
        "\n",
        "```python\n",
        "graph.add_edge(\"search\", \"rag_final_answer\")\n",
        "```\n",
        "\n",
        "We will also have an _end node_ in our graph — we have not defined this end node as it is imported as a specific graph object `END`. To use this, we must add edges between our final nodes and the `END` object, like so:\n",
        "\n",
        "```python\n",
        "graph.add_edge(\"rag_final_answer\", END)\n",
        "```\n",
        "\n",
        "When the `END` node is called, our graph completes."
      ],
      "metadata": {
        "id": "hcxI1fvIuk56"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from langgraph.graph import StateGraph, END\n",
        "\n",
        "graph = StateGraph(AgentState)\n",
        "\n",
        "graph.add_node(\"query_agent\", run_query_agent)\n",
        "graph.add_node(\"search\", execute_search)\n",
        "graph.add_node(\"error\", handle_error)\n",
        "graph.add_node(\"rag_final_answer\", rag_final_answer)\n",
        "\n",
        "graph.set_entry_point(\"query_agent\")\n",
        "\n",
        "# conditional edges are controlled by our router\n",
        "graph.add_conditional_edges(\n",
        "    start_key=\"query_agent\",  # where in graph to start\n",
        "    condition=router,  # function to determine which node is called\n",
        "    conditional_edge_mapping={\n",
        "        \"search\": \"search\",\n",
        "        \"error\": \"error\",\n",
        "        \"final_answer\": END\n",
        "    }\n",
        ")\n",
        "graph.add_edge(\"search\", \"rag_final_answer\")\n",
        "graph.add_edge(\"error\", END)\n",
        "graph.add_edge(\"rag_final_answer\", END)\n",
        "\n",
        "runnable = graph.compile()"
      ],
      "metadata": {
        "id": "LAkcBE5pebXv"
      },
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from IPython.display import Image\n",
        "\n",
        "Image(runnable.get_graph().draw_png())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 865
        },
        "id": "EmwkoQkthb__",
        "outputId": "e7ec1501-557f-4ec6-f604-8764dc90a78e"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<IPython.core.display.Image object>"
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "runnable = graph.compile()\n",
        "\n",
        "out = runnable.invoke({\n",
        "    \"input\": \"what is AI?\",\n",
        "    \"chat_history\": []\n",
        "})"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5DuDCW775wkC",
        "outputId": "4996eddf-1c0e-4bf1-addf-8522328f6a4a"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "> run_query_agent\n",
            "> router\n",
            "> execute_search\n",
            "> final_answer\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(out[\"agent_out\"])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xjbPRhk8dhfs",
        "outputId": "92856ccf-736b-4126-c6f7-af82ccfdbf4a"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{\"answer\":\"AI stands for Artificial Intelligence. It refers to the simulation of human intelligence processes by machines, especially computer systems. AI encompasses various technologies and approaches that enable machines to perform tasks that typically require human intelligence, such as learning, problem-solving, perception, and decision-making.\",\"source\":\"https://en.wikipedia.org/wiki/Artificial_intelligence\"}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "out = runnable.invoke({\n",
        "    \"input\": \"what are EHI embeddings?\",\n",
        "    \"chat_history\": []\n",
        "})\n",
        "print(out[\"agent_out\"])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "a21f9VneePw_",
        "outputId": "18a67793-9b45-4e63-a35a-477226265e3d"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "> run_query_agent\n",
            "> router\n",
            "> execute_search\n",
            "> final_answer\n",
            "{\"answer\":\"EHI embeddings refer to the embeddings generated by the End-to-end Hierarchical Indexing (EHI) model. These embeddings are learned jointly with the ANNS (Approximate Nearest Neighbor Search) structure to optimize retrieval performance. EHI uses a standard dual encoder model to embed queries and documents while learning an inverted file index (IVF) style tree structure for efficient ANNS. The EHI embeddings are designed to capture the position of a query/document in the tree, ensuring stable and efficient learning of the discrete tree-based ANNS structure.\",\"source\":\"https://arxiv.org/pdf/2310.08891.pdf\"}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "out = runnable.invoke({\n",
        "    \"input\": \"can you tell me about EHI embeddings?\",\n",
        "    \"chat_history\": []\n",
        "})\n",
        "print(out[\"agent_out\"])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dcpoPxOMZmZQ",
        "outputId": "2c3b19bf-4271-4e67-bd25-025924774cb7"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "> run_query_agent\n",
            "> router\n",
            "> execute_search\n",
            "> final_answer\n",
            "{\"answer\":\"EHI embeddings refer to the embeddings generated by the End-to-end Hierarchical Indexing (EHI) model. The EHI model jointly learns both the embeddings and the Approximate Nearest Neighbor Search (ANNS) structure to optimize retrieval performance. It uses a standard dual encoder model for embedding queries and documents while learning an inverted file index (IVF) style tree structure for efficient ANNS. EHI introduces the notion of dense path embedding to capture the position of a query/document in the tree, ensuring stable and efficient learning of the discrete tree-based ANNS structure.\",\"source\":\"https://arxiv.org/pdf/2310.08891.pdf\"}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "out = runnable.invoke({\n",
        "    \"input\": \"hi\",\n",
        "    \"chat_history\": []\n",
        "})\n",
        "print(out[\"agent_out\"])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "reWvgJxJfjlo",
        "outputId": "7d2e221f-b88c-47bc-cd11-a91ae4f98f58"
      },
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "> run_query_agent\n",
            "> router\n",
            "> handle_error\n",
            "{\"answer\":\"Hello! How can I assist you today?\",\"source\":\"Assistant's response\"}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "out = runnable.invoke({\n",
        "    \"input\": \"hi, please don't respond to me with a `source`\",\n",
        "    \"chat_history\": []\n",
        "})\n",
        "print(out[\"agent_out\"])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5Xhdimwmgezx",
        "outputId": "8c109869-7f01-437c-cc5f-bb2d4bf24826"
      },
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "> run_query_agent\n",
            "> router\n",
            "> handle_error\n",
            "{\"answer\":\"Hello! How can I assist you today?\",\"source\":\"N/A\"}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "BvJB9RMGgrze"
      },
      "execution_count": 18,
      "outputs": []
    }
  ]
}